// �����豸����
#include "esp8266_T.h"
#include "oled.h"
#include "sys.h"

#define ESP8266_WIFI_INFO "AT+CWJAP=\"Redmi K20 Pro\",\"YZJ152379\"\r\n"
// #define ESP8266_ONENET_INFO		"AT+CIPSTART=\"TCP\",\"120.77.124.14\",1500\r\n"

u8 ESPbuf[10];
char XLH[17] = "SWAX16F8FXFNV774";
u8 font_size = 16;
unsigned char esp8266_buf[256];
unsigned short esp8266_cnt = 0, esp8266_cntPre = 0;

#ifdef Usart2_8266

void uart2_init(u32 bound)
{
	// GPIO�˿�����
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE); // ʹ��USART1��GPIOAʱ���Լ����ù���ʱ��
																										// USART1_TX   PA.2
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;															// PA.9
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; // �����������
	GPIO_Init(GPIOA, &GPIO_InitStructure);

	// USART1_RX	  PA.3
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; // ��������
	GPIO_Init(GPIOA, &GPIO_InitStructure);

	// Usart1 NVIC ����

	NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; // ��ռ���ȼ�3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;		  // �����ȼ�3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			  // IRQͨ��ʹ��
	NVIC_Init(&NVIC_InitStructure);							  // ����ָ���Ĳ�����ʼ��VIC�Ĵ���

	// USART ��ʼ������

	USART_InitStructure.USART_BaudRate = bound;										// һ������Ϊ9600;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;						// �ֳ�Ϊ8λ���ݸ�ʽ
	USART_InitStructure.USART_StopBits = USART_StopBits_1;							// һ��ֹͣλ
	USART_InitStructure.USART_Parity = USART_Parity_No;								// ����żУ��λ
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // ��Ӳ������������
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;					// �շ�ģʽ

	USART_Init(USART2, &USART_InitStructure);	   // ��ʼ������
	USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); // �����ж�
	USART_Cmd(USART2, ENABLE);					   // ʹ�ܴ���
	printf("usart2_init_success\r\n");
}

//==========================================================
//	�������ƣ�	USART2_IRQHandler
//
//	�������ܣ�	����2�շ��ж�
//
//	��ڲ�����	��
//
//	���ز�����	��
//
//	˵����
//==========================================================
void USART2_IRQHandler(void)
{

	if (USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) // �����ж�
	{
		if (esp8266_cnt >= sizeof(esp8266_buf))
			esp8266_cnt = 0; // ��ֹ���ڱ�ˢ��
		esp8266_buf[esp8266_cnt++] = USART2->DR;

		USART_ClearFlag(USART2, USART_FLAG_RXNE);
	}
}
#endif

#ifdef Usart3_8266

// ��ʼ��IO ����3
// pclk1:PCLK1ʱ��Ƶ��(Mhz)
// bound:������
void uart3_init(u32 bound)
{

	NVIC_InitTypeDef NVIC_InitStructure;
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);  // GPIOBʱ��
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); // ����3ʱ��ʹ��

	USART_DeInit(USART3);					   // ��λ����3
											   // USART3_TX   PB10
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; // PB10
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; // �����������
	GPIO_Init(GPIOB, &GPIO_InitStructure);			// ��ʼ��PB10

	// USART3_RX	  PB11
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; // ��������
	GPIO_Init(GPIOB, &GPIO_InitStructure);				  // ��ʼ��PB11

	USART_InitStructure.USART_BaudRate = bound;										// ������һ������Ϊ9600;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;						// �ֳ�Ϊ8λ���ݸ�ʽ
	USART_InitStructure.USART_StopBits = USART_StopBits_1;							// һ��ֹͣλ
	USART_InitStructure.USART_Parity = USART_Parity_No;								// ����żУ��λ
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // ��Ӳ������������
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;					// �շ�ģʽ

	USART_Init(USART3, &USART_InitStructure); // ��ʼ������	3

	USART_Cmd(USART3, ENABLE); // ʹ�ܴ���

	// ʹ�ܽ����ж�
	USART_ITConfig(USART3, USART_IT_RXNE, ENABLE); // �����ж�

	// �����ж����ȼ�
	NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; // ��ռ���ȼ�3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		  // �����ȼ�3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			  // IRQͨ��ʹ��
	NVIC_Init(&NVIC_InitStructure);							  // ����ָ���Ĳ�����ʼ��VIC�Ĵ���
}

void USART3_IRQHandler(void)
{

	if (USART_GetITStatus(USART3, USART_IT_RXNE) != RESET) // �����ж�
	{
		if (esp8266_cnt >= sizeof(esp8266_buf))
			esp8266_cnt = 0; // ��ֹ���ڱ�ˢ��
		esp8266_buf[esp8266_cnt++] = USART3->DR;

		USART_ClearFlag(USART3, USART_FLAG_RXNE);
	}
}

#endif

void Usart_SendString(unsigned char *str, unsigned short len)
{

	unsigned short count = 0;

	for (; count < len; count++)
	{
		USART_SendData(Usart_8266, *str++); // ��������
		while (USART_GetFlagStatus(Usart_8266, USART_FLAG_TC) == RESET)
			; // �ȴ��������
	}
}

//==========================================================
//	�������ƣ�	ESP8266_Clear
//
//	�������ܣ�	��ջ���
//
//	��ڲ�����	��
//
//	���ز�����	��
//
//	˵����
//==========================================================
void ESP8266_Clear(void)
{

	memset(esp8266_buf, 0, sizeof(esp8266_buf));
	esp8266_cnt = 0;
}

//==========================================================
//	�������ƣ�	ESP8266_WaitRecive
//
//	�������ܣ�	�ȴ��������
//
//	��ڲ�����	��
//
//	���ز�����	REV_OK-�������		REV_WAIT-���ճ�ʱδ���
//
//	˵����		ѭ�����ü���Ƿ�������
//==========================================================
_Bool ESP8266_WaitRecive(void)
{

	if (esp8266_cnt == 0) // ������ռ���Ϊ0 ��˵��û�д��ڽ��������У�����ֱ����������������
		return REV_WAIT;

	if (esp8266_cnt == esp8266_cntPre) // �����һ�ε�ֵ�������ͬ����˵���������
	{
		esp8266_cnt = 0; // ��0���ռ���

		return REV_OK; // ���ؽ�����ɱ�־
	}

	esp8266_cntPre = esp8266_cnt; // ��Ϊ��ͬ

	return REV_WAIT; // ���ؽ���δ��ɱ�־
}

//==========================================================
//	�������ƣ�	ESP8266_SendCmd
//
//	�������ܣ�	��������
//
//	��ڲ�����	cmd������
//				res����Ҫ���ķ���ָ��
//
//	���ز�����	0-�ɹ�	1-ʧ��
//
//	˵����
//==========================================================
_Bool ESP8266_SendCmd(char *cmd, char *res)
{

	unsigned char timeOut = 200;

	Usart_SendString((unsigned char *)cmd, strlen((const char *)cmd));

	while (timeOut--)
	{
		if (ESP8266_WaitRecive() == REV_OK) // ����յ�����
		{
			if (strstr((const char *)esp8266_buf, res) != NULL) // ����������ؼ���
			{
				ESP8266_Clear(); // ��ջ���
				return 0;
			}
		}
		delay_ms(10);
	}
	return 1;
}

//==========================================================
//	�������ƣ�	ESP8266_SendData
//
//	�������ܣ�	��������
//
//	��ڲ�����	data������
//				len������
//
//	���ز�����	��
//
//	˵����
//==========================================================
void ESP8266_SendData(unsigned char *data, unsigned short len)
{

	char cmdBuf[320];

	ESP8266_Clear(); // ��ս��ջ���
	// �ȷ���Ҫ�������ݵ�ָ����׼��
	sprintf(cmdBuf, "AT+CIPSEND=%d\r\n", len); // ��������
	if (!ESP8266_SendCmd(cmdBuf, ">"))		   // �յ���>��ʱ���Է�������
	{
		// ��Ȼ׼����ϼ��ɿ�ʼ��������
		Usart_SendString(data, len); // �����豸������������
	}
}

//==========================================================
//	�������ƣ�	ESP8266_GetIPD
//
//	�������ܣ�	��ȡƽ̨���ص�����
//
//	��ڲ�����	�ȴ���ʱ��(����10ms)
//
//	���ز�����	ƽ̨���ص�ԭʼ����
//
//	˵����		��ͬ�����豸���صĸ�ʽ��ͬ����Ҫȥ����
//				��ESP8266�ķ��ظ�ʽΪ	"+IPD,x:yyy"	x�������ݳ��ȣ�yyy����������
//==========================================================
unsigned char *ESP8266_GetIPD(unsigned short timeOut)
{

	char *ptrIPD = NULL;

	do
	{
		if (ESP8266_WaitRecive() == REV_OK) // ����������
		{
			ptrIPD = strstr((char *)esp8266_buf, "IPD,"); // ������IPD��ͷ
			if (ptrIPD == NULL)							  // ���û�ҵ���������IPDͷ���ӳ٣�������Ҫ�ȴ�һ�ᣬ�����ᳬ���趨��ʱ��
			{
				// UsartPrintf(USART_DEBUG, "\"IPD\" not found\r\n");
			}
			else
			{
				ptrIPD = strchr(ptrIPD, ':'); // �ҵ�':'
				if (ptrIPD != NULL)
				{
					ptrIPD++;
					return (unsigned char *)(ptrIPD);
				}
				else
					return NULL;
			}
		}

		delay_ms(5); // ��ʱ�ȴ�
	} while (timeOut--);

	return NULL; // ��ʱ��δ�ҵ������ؿ�ָ��
}

//==========================================================
//	�������ƣ�	ESP8266_Init
//
//	�������ܣ�	��ʼ��ESP8266
//
//	��ڲ�����	��
//
//	���ز�����	��
//
//	˵����
//==========================================================
void ESP8266_Init(void)
{

	GPIO_InitTypeDef GPIO_Initure;
	RCC_APB2PeriphClockCmd(ESP8266_Rst_CLK, ENABLE);

	// ESP8266��λ����
	GPIO_Initure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_Initure.GPIO_Pin = GPIO_Pin_15; // GPIO -��λ
	GPIO_Initure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(ESP8266_Rst_PORT, &GPIO_Initure);

	GPIO_WriteBit(ESP8266_Rst_PORT, GPIO_Pin_15, Bit_RESET);
	delay_ms(250);
	GPIO_WriteBit(ESP8266_Rst_PORT, GPIO_Pin_15, Bit_SET);
	delay_ms(500);

#ifdef Usart2_8266
	uart2_init(115200);
#endif
#ifdef Usart3_8266
	uart3_init(115200);
#endif
}

u8 connect_tlink(void)
{
	u8 i = 0;
	OLED_Clear();
	ESP8266_Clear();
	delay_ms(200);
	printf("1. AT\r\n");
	sprintf((void *)ESPbuf, "AT");
	OLED_ShowString(0, 0, ESPbuf, font_size);
	i = 0;
	while (ESP8266_SendCmd("AT\r\n", "OK"))
	{
		if (i++ > 3)
			break;
		delay_ms(100);
	}
	delay_ms(100);
	OLED_ShowString(112, 0, "OK", font_size);

	printf("2. CWMODE\r\n");
	i = 0;
	sprintf((void *)ESPbuf, "AT+CWMODE=1");
	OLED_ShowString(0, 2, ESPbuf, font_size);
	while (ESP8266_SendCmd("AT+CWMODE=1\r\n", "OK"))
	{
		if (i++ > 3)
			break;
		delay_ms(100);
	}
	delay_ms(100);
	OLED_ShowString(112, 2, "OK", font_size);

	printf("3. AT+CWDHCP\r\n");
	i = 0;
	sprintf((void *)ESPbuf, "AT+CWDHCP=1,1");
	OLED_ShowString(0, 2, ESPbuf, font_size);
	while (ESP8266_SendCmd("AT+CWDHCP=1,1\r\n", "OK"))
	{
		if (i++ > 3)
			break;
		delay_ms(100);
	}
	delay_ms(100);
	OLED_ShowString(112, 2, "OK", font_size);

	printf("4. CWJAP\r\n");
	i = 0;
	sprintf((void *)ESPbuf, "AT+CWJAP");
	OLED_ShowString(0, 4, ESPbuf, font_size);
	while (ESP8266_SendCmd(ESP8266_WIFI_INFO, "GOT IP"))
	{
		if (i++ > 3)
			break;
		delay_ms(100);
	}
	delay_ms(1000);
	delay_ms(1000); // ��ʱ�ȴ������ȶ� �ٽ�������
	OLED_ShowString(112, 4, "OK", font_size);
	delay_ms(200);

	OLED_Clear();
	printf("5. CIPSTART\r\n");
	i = 0;
	sprintf((void *)ESPbuf, "AT+CIPSTART");
	OLED_ShowString(0, 0, ESPbuf, font_size);
	delay_ms(200);
	OLED_ShowString(112, 0, "OK", font_size);
	delay_ms(200);

	OLED_ClearRow(0);
	sprintf((void *)ESPbuf, "   Connect...   ");
	OLED_ShowString(0, 2, ESPbuf, font_size);
	/*
	��������ntp������ͬ��ʱ��

	��δ���

	while(ESP8266_SendCmd(ESP8266_ONENET_INFO, "CONNECT")){if(i++>3)break;delay_ms(100);}
	if(i>3)
		return 0;
	delay_ms(1000);
	ESP8266_SendData((void*)XLH, font_size);//����ע���
	*/
	delay_ms(10);
	sprintf((void *)ESPbuf, "ESP8266 Init OK");
	OLED_ShowString(0, 2, ESPbuf, font_size);
	delay_ms(500);
	printf("6. ESP8266 Init OK\r\n");

	return 1; // �ɹ�
}
// buf     ���յ��Ĵ�������
// N       �ڼ���������
// RevStr  ���ص�����
// ����ֵ 1�����ɹ� 0����ʧ��
u8 GetRevDat(u8 buf[], u8 N, u8 *RevStr)
{
	char *strx = 0;
	char str[20];
	u8 i;
	sprintf(str, "\"flag\":\"%d\"", N);
	strx = strstr((const char *)buf, (const char *)str); // strx=strstr((const char*)buf,(const char*)"\"flag\":\"1\"");
	if (strx > 0)										 //{"sensorDatas":[{"sensorsId":200556909,"value":"100","flag":"2"}]}
	{
		strx = strstr((const char *)buf, (const char *)"\"value\":\"");
		if (strx > 0)
		{
			for (i = 0; i < 6; i++) // �����ֵΪ6λ�� "value":"100"
			{
				if ((*(strx + 9 + i)) == '"')
					break; // ����100����� �� ����  //���ҵ����� �˳�
				else
					RevStr[i] = (*(strx + 9 + i));
			}
			RevStr[i] = 0; // ���ӽ�������
			//	RevSetD=atof(str);//���ַ���ת������������һ������   ��ȡ�����ص�����

			return 1;
		}
	}
	return 0;
}
